package com.javenwong.android.engine.scene;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;

import com.javenwong.android.engine.GameActivity;
import com.javenwong.android.engine.GameCanvas;
import com.javenwong.android.engine.Graphics;
import com.javenwong.android.engine.ImageManager;

/**
 * 地图
 * @author 王晓锋
 * @version 1.00
 */
public class Map{
	
	/** 地图id -> 对应 {id}.m 文件 */
	private final String id;

	/** 摄像机 */
	private Camera camera;
	
	/** 加载地图的时用到的图片数量 */
	private int imageNum;
	/** 图片数组 */
	private Bitmap img[];
	/** 行数，列数 */
	private int row = -1;
	private int col = -1;
	/** 层数 */
	protected int layerCount = 0;
	/** 三层 */
	private int tiles[][][];
	private int cells[][][];
	private int transs[][][];
	/** 一行有多少格 */
	private int[] img_rowNum;
	/** 通行数据 */
	private int pass[][];
	
	private boolean isWobble;

	/** 左脚，右脚 */
	public static int c1 = 0, r1 = 0, c2 = 0, r2 = 0;
	
//	private Bitmap mapImage;

	public Map(String id, Camera camera){
		this.id = id;
		this.camera = camera;
		
		loadMap(id);
		
//		mapImage = Bitmap.createImage(getWidth(), getHeight());
	}

	public boolean isWobble() {
		return isWobble;
	}

	public void setWobble(boolean isWobble) {
		this.isWobble = isWobble;
	}

	/**
	 * 加载地图数据示例
	 * @param mapId
	 */
	public void loadMap(String mapId) {
		InputStream in = null;
		try {
			in = GameActivity.assetManager.open("map/" + mapId + ".m");

			DataInputStream dis = new DataInputStream(in);
			
			imageNum = in.read() & 0xff;// 地图用到的图片的数量
			img = new Bitmap[imageNum]; // 初始化图片数组
			img_rowNum = new int[imageNum]; // 初始化图片一行的格子数
						
			for (int i = 0; i < imageNum; i++) {
				// int mid = in.read(); // 图片的 id
//				img[i] = Bitmap.createImage("/map/t_" + in.read() + ".png");
				img[i] = BitmapFactory.decodeStream(GameActivity.assetManager.open("map/t_" + (in.read() & 0xff) + ".png"));
				img_rowNum[i] = img[i].getWidth() / 16;
			}

			// 读行和列
			row = in.read() & 0xff; // 读取行数
			col = in.read() & 0xff; // 读取列数
			layerCount = in.read() & 0xff; //层数
			// 读取地图
			tiles = new int[layerCount][][];
			cells = new int[layerCount][][];
			transs = new int[layerCount][][];
			for (int layer = 0; layer < tiles.length; layer++) {
				tiles[layer] = new int[row][col];
				cells[layer] = new int[row][col];
				transs[layer] = new int[row][col];
				
				for (int r = 0; r < row; r++) {
					for (int c = 0; c < col; c++) {
						int imgIndex = in.read() & 0xff; // 用到的图片索引
						if (imgIndex != 255) {
//							int cellIndex = in.read() & 0xff; // 第几个图块
							int cellIndex = dis.readInt(); // 第几个图块
							int trans = in.read() & 0xff; // 是否翻转
							// 用移位的方法把三个int 形数据放到一个数组里，移的2进制
//							System.out.println("read imgIndex: "+imgIndex);
//							tiles[layer][r][c] = (imgIndex << 16) + (cellIndex << 8) + trans;
							tiles[layer][r][c] = imgIndex;
							cells[layer][r][c] = cellIndex;
							transs[layer][r][c] = trans;
						} else {
							tiles[layer][r][c] = -1;
						}
					}
				}
			}
			// 通行数据
			pass = new int[row][col + 1];
			for (int c = 0; c < row; c++) {
				for (int r = 0; r < col; r++) {
					pass[c][r] = in.read();
					
//					if (pass == 0) {
//						// 该格子能通行
//					} else {
//						// 该格子不能通行
//						// 2：梯子
//						// 3：墙
//						// 4：栏杆
//						// 5：箱子
//					}
				}
			}
		
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				in.close();
			} catch (IOException e) {
			}
		}
	}
	
	//先将要循环的地图画到图片中，以节省重复绘制次数
//	public void draw(Graphics g, int layer, byte hfor, byte vfor) {
//
//		// 控制地图是否可以颤抖
//		if (isWobble) {
//			g.translate(0, 5);
//		}
//		
//		Graphics old = g;
//		
//		g = mapImage.getGraphics();
//		//先将要循环的地图画到图片中，以节省重复绘制次数
//		for (int r = 0; r < row; r++) {
//			for (int c = 0; c < col; c++) {
//				if (tiles[layer][r][c] != -1) {
//
//					// 把数据用移位的方法移出来
//					int imgIndex = (tiles[layer][r][c] >> 16);
//					int cellIndex = (tiles[layer][r][c] >> 8) & 0xff;
//					int trans = tiles[layer][r][c] & 0xff;
//
//					// 一行的有几个格
//					int tempImgRow = img_rowNum[imgIndex];
//					// 取图块在图片 的位置
//					int x = (cellIndex % tempImgRow) * 16; // 图块在图片的X
//					int y = (cellIndex / tempImgRow) * 16; // 图块在图片的Y
//
//					// 取把图块画的方位
//					int screenX = c * 16, screenY = r * 16;
//
//					// 处理旋转
//					switch (trans) {
//					case 1:
//						trans = Sprite.TRANS_MIRROR;
//						break;
//					case 2:
//						trans = Sprite.TRANS_MIRROR_ROT180;
//						break;
//					case 3:
//						trans = Sprite.TRANS_ROT180;
//						break;
//					}
//					// 开始画地图
////					Tools.drawRegion(g, img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
//					g.drawRegion(img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
//				}
//			}
//		}
//		
//		int mapx = 0;
//
//		for(byte h=0;h<hfor;h++){
//			int mapy = 0;
//			
//			for(byte v=0;v<vfor;v++){
//				old.drawImage(mapImage, mapx-camera.getX(), mapy-camera.getY(), Graphics.LEFT|Graphics.TOP);
//				
//				mapy+=getHeight();
//			}
//			mapx+=getWidth();
//		}
//
//		// 地图颤抖
//		if (isWobble) {
//			isWobble = false;
//			g.translate(0, -5);
//		}
//
//	}

	//只画当前屏幕显示的部分
//	public void draw(Graphics g, int layer, byte hfor, byte vfor) {
//		
////		System.out.println(Constant.SW+" , "+Constant.SH);
////		System.out.println(getWidth()+" , "+getHeight());
//		
//		int wc = 0, hc = 0;		//绘制的 宽、高
//
//		// 控制地图是否可以颤抖
//		if (isWobble) {
//			g.translate(0, 5);
//		}
//		
//		int mapx = 0;
//
//		//横向循环
//		for(byte h=0;h<hfor;h++){
//			int mapy = 0;
//			
//			//纵向循环
//			for(byte v=0;v<vfor;v++){
//				
////				if (h==1 && v==0) break;
//				
//				//循环画第一行
//				for (int r = 0; r < row; r++) {
//					int screenY = r * 16 - camera.getY()+mapy;
//					
//					if (h==0) hc+=16;
//					
//					//循环一行中每一列的图块
//					for (int c = 0; c < col; c++) {
//						if (tiles[layer][r][c] != -1) {
//
//							// 把数据用移位的方法移出来
//							int imgIndex = (tiles[layer][r][c] >> 16);
//							int cellIndex = (tiles[layer][r][c] >> 8) & 0xff;
//							int trans = tiles[layer][r][c] & 0xff;
//
//							// 一行的有几个格
//							int tempImgRow = img_rowNum[imgIndex];
//							// 取图块在图片 的位置
//							int x = (cellIndex % tempImgRow) * 16; // 图块在图片的X
//							int y = (cellIndex / tempImgRow) * 16; // 图块在图片的Y
//
//							// 取把图块画的方位
//							int screenX = c * 16 - camera.getX()+mapx;
//							
//							if (v==0 && r==0) wc+=16;
//							
//							if (wc>Constant.SW && hc>Constant.SH){
//								
//								System.out.println(wc+" , "+hc);
//								
//								return;
//							}
//							
////							System.out.println(screenX+" , "+screenY);
//							
////							if (screenX>Constant.SW && screenY>Constant.SH){
////								return;
////							}
////							if (screenX<0 && screenY<0){
////								return;
////							}
//							
////							wc+=screenX;
////							hc+=screenY;
////							
////							System.out.println(wc+" , "+hc);
////							
////							if (wc>Constant.SW && hc>Constant.SH){
////								return;
////							}
//
//							// 处理旋转
//							switch (trans) {
//							case 1:
//								trans = Sprite.TRANS_MIRROR;
//								break;
//							case 2:
//								trans = Sprite.TRANS_MIRROR_ROT180;
//								break;
//							case 3:
//								trans = Sprite.TRANS_ROT180;
//								break;
//							}
//							
//							// 开始画地图
////							Tools.drawRegion(g, img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
//							g.drawRegion(img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
//							
//						}
//					}
////					return;
//				}
//				mapy+=getHeight();
//			}
//			mapx+=getWidth();
//		}
//
//		// 地图颤抖
//		if (isWobble) {
//			isWobble = false;
//			g.translate(0, -5);
//		}
//
////		System.out.println(wc+" , "+hc);
//		
////		System.out.println("==========================");
//	}
	
	//普通绘制（性能不好）
//	public void draw(Graphics g, int layer, byte hfor, byte vfor) {
//
//		// 控制地图是否可以颤抖
//		if (isWobble) {
//			g.translate(0, 5);
//		}
//		
//		int mapx = 0;
//
//		for(byte h=0;h<hfor;h++){
//			int mapy = 0;
//			
//			for(byte v=0;v<vfor;v++){
//				
//				for (int r = 0; r < row; r++) {
//					for (int c = 0; c < col; c++) {
//						if (tiles[layer][r][c] != -1) {
//
//							// 把数据用移位的方法移出来
//							int imgIndex = (tiles[layer][r][c] >> 16);
//							int cellIndex = (tiles[layer][r][c] >> 8) & 0xff;
//							int trans = tiles[layer][r][c] & 0xff;
//
//							// 一行的有几个格
//							int tempImgRow = img_rowNum[imgIndex];
//							// 取图块在图片 的位置
//							int x = (cellIndex % tempImgRow) * 16; // 图块在图片的X
//							int y = (cellIndex / tempImgRow) * 16; // 图块在图片的Y
//
//							// 取把图块画的方位
//							int screenX = c * 16 - camera.getX()+mapx, screenY = r * 16 - camera.getY()+mapy;
//
//							// 处理旋转
//							switch (trans) {
//							case 1:
//								trans = Sprite.TRANS_MIRROR;
//								break;
//							case 2:
//								trans = Sprite.TRANS_MIRROR_ROT180;
//								break;
//							case 3:
//								trans = Sprite.TRANS_ROT180;
//								break;
//							}
//							// 开始画地图
////							Tools.drawRegion(g, img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
//							g.drawRegion(img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
//						}
//					}
//				}
//				mapy+=getHeight();
//			}
//			mapx+=getWidth();
//		}
//
//		// 地图颤抖
//		if (isWobble) {
//			isWobble = false;
//			g.translate(0, -5);
//		}
//
//	}

	public void draw(Canvas g){
		for(int layer=0;layer<layerCount;layer++){
			draw(g, layer);
		}
	}
	
	public void draw(Canvas g, int layer) {
		
//		int drawCount = 0;
		
		for (int r = 0; r < row; r++) {
			for (int c = 0; c < col; c++) {
				if (tiles[layer][r][c] != -1) {

					// 取把图块画的方位
					int screenX = c * 16 - camera.getX(), screenY = r * 16 - camera.getY();
					
//					System.out.println(screenX+" , "+screenY);
					
					//不显示的部分不绘制
					if (screenX+16<0 || screenY+16<0){
						continue;
					}
					if (screenX>ImageManager.STANDARD_WIDTH || screenY>ImageManager.STANDARD_HEIGHT){
						continue;
					}
					
					// 把数据用移位的方法移出来
//					int imgIndex = (tiles[layer][r][c] >> 16);
//					int cellIndex = (tiles[layer][r][c] >> 8) & 0xff;
//					int trans = tiles[layer][r][c] & 0xff;
					
					int imgIndex = tiles[layer][r][c];
					int cellIndex = cells[layer][r][c];
					int trans = transs[layer][r][c];
					

					// 一行的有几个格
//					System.out.println("imgIndex: "+imgIndex);
//					System.out.println("img_rowNum: "+img_rowNum.length);
					
//					if (imgIndex>=img_rowNum.length){
//						continue;
//					}
					
					int tempImgRow = img_rowNum[imgIndex];
					// 取图块在图片 的位置
					int x = (cellIndex % tempImgRow) * 16; // 图块在图片的X
					int y = (cellIndex / tempImgRow) * 16; // 图块在图片的Y
					
					// 处理旋转
					switch (trans) {
					case 1:
						trans = Graphics.TRANS_MIRROR;
						break;
					case 2:
						trans = Graphics.TRANS_MIRROR_ROT180;
						break;
					case 3:
						trans = Graphics.TRANS_ROT180;
						break;
					}
					// 开始画地图
//					Tools.drawRegion(g, img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
//					g.drawRegion(img[imgIndex], x, y, 16, 16, trans, screenX, screenY, 0);
					Graphics.drawRegion(g, img[imgIndex], x, y, 16, 16, trans, screenX, screenY, Graphics.TOP|Graphics.LEFT);
					
//					drawCount++;
					
					//画障碍
//					if (pass[r][c]!=0){
//						g.setColor(0xFF0000);
//						g.drawRect(screenX, screenY, 16, 16);
//					}
				}
				
			}
		}

		// 地图颤抖
		if (isWobble) {
			isWobble = false;
			g.translate(0, -5);
		}


//		System.out.println(drawCount+"==================");
	}

	/**
	 * 是否能通过
	 * 
	 * @param x
	 *            人物的X坐标
	 * @param y
	 *            人物的Y坐标
	 * @param speed
	 *            步长
	 * @param dir
	 *            方向
	 * @param rw
	 *            判断通过的宽度
	 * @param rh
	 *            判断通过的高度
	 * @return 是否能通过
	 */
	public boolean canPass(int x, int y, int speed, int dir, int rw, int rh) {

		int cx = x, cy = y; // 人物坐标

		switch (dir) {
		case 0: // up
			cy -= speed;
			r1 = r2 = (cy - (rh >> 1)) / 16; // 人物向上移动时右边位置所占的行（Ｙ）
			c1 = (x + (rw >> 1)) / 16; // X
			c2 = (x - (rw >> 1)) / 16; // X

			break;
		case 1: // down

			cy += speed;
			r1 = r2 = (cy + (rh >> 1)) / 16; // 人物向上移动时右边位置所占的行
			c1 = (x - (rw >> 1)) / 16;
			c2 = (x + (rw >> 1)) / 16;
			break;
		case 2: // left

			// lrx = x - rh >> 1;// 左右移动时人物的x坐标

			cx -= speed;
			c1 = c2 = (cx - (rw >> 1)) / 16;
			r1 = (y + (rh >> 1)) / 16;
			r2 = (y - (rh >> 1)) / 16;
			break;
		case 3: // right

			// lrx = x + rh >> 1;// 左右移动时人物的x坐标
			cx += speed;
			c1 = c2 = (cx + (rw >> 1)) / 16;

			r1 = (y - (rh >> 1)) / 16;
			r2 = (y + (rh >> 1)) / 16;

			break;
		}
		// 判断场景的四周是否出界
		if (cx < 0 || cx > this.col * 16 || cy < 0 || cy > this.row * 16) {
			return false;
		}
		if (r1 < 0 || r1 >= pass.length || c1 < 0 || c1 >= pass[0].length || pass[r1][c1] == 1 || pass[r2][c2] == 1) {

			return false;
		}

		return pass[r1][c1] == 0 && pass[r2][c2] == 0;

	}
	
	public boolean canPass(int x, int y){
		return pass[(x+camera.getX())/16][(y+camera.getY())/16]==0;	
	}

	/**
	 * 获取地图的宽度
	 * 
	 * @return
	 */
	public int getWidth() {
		return col * 16;
	}

	/**
	 * 获取地图的高度
	 * 
	 * @return
	 */
	public int getHeight() {
		return row * 16;
	}

	/**
	 * 清除用过的存放实体的集合
	 */
	public void clear() {
		tiles = null;
		pass = null;
		img = null;
		img_rowNum = null;

	}

	//重复地图数据
	public void processHVFor(byte hfor, byte vfor){
		
		if (hfor==1 && vfor==1) return;
		
		//扩充地图数据
		for(int layer=0;layer<3;layer++){
			int[][] old1 = tiles[layer];
			int[][] old2 = cells[layer];
			int[][] old3 = transs[layer];
			
			tiles[layer] = new int[row*vfor][col*hfor];
			cells[layer] = new int[row*vfor][col*hfor];
			transs[layer] = new int[row*vfor][col*hfor];

			for (int r = 0, t=0; r < tiles[layer].length; r++,t++) {
				for (int c = 0, k=0; c < tiles[layer][0].length; c++,k++) {
					tiles[layer][r][c] = old1[t][k];
					cells[layer][r][c] = old2[t][k];
					transs[layer][r][c] = old3[t][k];
			
					if ((k+1)%col==0){
						k = -1;						
					}
				}
				
				if ((t+1)%row==0){
					t = -1;
				}
			}
			
		}
		
		//扩充通行数据
		int[][] old = pass;
		pass = new int[row*vfor][col*hfor];
		for (int r = 0, t=0; r < pass.length; r++,t++) {
			for (int c = 0, k=0; c < pass[0].length; c++,k++) {
				pass[r][c] = old[t][k];
									
				if ((k+1)%col==0){
					k = -1;						
				}
			}
			
			if ((t+1)%row==0){
				t = -1;
			}
		}

		row = row*vfor;
		col = col*hfor;
	}

	public int[][] getPass() {
		return pass;
	}
}


















